# -*- coding: UTF-8 -*-

from Position import *
from Vehicule import *
from PlacementAleatoire import *
import random
import copy

class LignePlancheDeJeu():
    def __init__(self, largeur=10, direction=0.01, gapMinimal=2):
        self.largeur = largeur
        self.listeElements=[]
        self.direction = direction
        self.gapMinimal = gapMinimal
        self.varFonction = self.defaultAction
    
    def moveLine(self):
        for elem in self.listeElements:
            elem.move(self.direction)
        self.rotationMap()
            
    def rotationMap(self):
        for j in self.listeElements: 
                #Si la ligne va vers la droite
                if self.direction > 0:
                    if(j.pos.x+j.largeur >= self.largeur):
                        if not j.sorti:
                            j.sorti = True
                            aAjouter = copy.copy(j)
                            aAjouter.pos = Position(j.pos.x-self.largeur, None)
                            aAjouter.sorti = False
                            self.ajouterElement(aAjouter)
                        if j.pos.x >= self.largeur:
                            if j in self.listeElements:
                                self.listeElements.remove(j)
                #Si la ligne va vers la gauche
                elif self.direction < 0:
                    if(j.pos.x <= 0):
                        if not j.sorti:
                            j.sorti = True
                            aAjouter = copy.copy(j)
                            aAjouter.pos = Position(j.pos.x+self.largeur, None)
                            aAjouter.sorti = False
                            self.ajouterElement(aAjouter)
                        if j.pos.x+j.largeur <= 0:
                                self.listeElements.remove(j)
    
    def verifierCollisions(self, joueur):
        for elem in self.listeElements:
            if joueur.pos.x < elem.pos.x:
                if joueur.pos.x + joueur.largeur > elem.pos.x:
                    return True
            else:
                if elem.pos.x + elem.largeur > joueur.pos.x:
                    return True
        
        return False
            
    def verifierCollisionsGap(self, joueur, profondeur = 0):
        for i in self.listeElements:
            if joueur.pos.x + joueur.largeur - profondeur < i.pos.x:
                pass
            elif joueur.pos.x + profondeur > i.pos.x+i.largeur:
                pass
            else:
                return i
        
        return None
    
    def verifierMultiplesCollisions(self, joueur, profondeur = 0):
        array = []
        for i in self.listeElements:
            #print "PP", joueur.pos.x + joueur.largeur - profondeur, i.pos.x
            #print "PG", joueur.pos.x + profondeur, i.pos.x+i.largeur
            if joueur.pos.x + joueur.largeur + profondeur < i.pos.x:
                pass
            elif joueur.pos.x - profondeur > i.pos.x+i.largeur:
                pass
            else:
                #print joueur, i
                array.append(i)
        
        return array
    
    def verifierErreurs(self):
        #print "ON RENTRE DANS VÉRIFIER ERREUR !!!!! pour : ", self
        for i in self.listeElements:
            value = self.verifierMultiplesCollisions(i, 1)
            for j in value:
                if i is not j:
                    print j
                    self.listeElements.remove(i)
                    
            
    def defaultAction(self, joueur):
        pass
    
    
    def ajouterElement(self, elem):
        self.listeElements.append(elem)
        
    def verifierLimitesGrenouille(self, joueur):
        if joueur.pos.x < 0 :
            joueur.pos.x = 0
        
        elif joueur.pos.x+joueur.largeur > self.largeur:
            joueur.pos.x = self.largeur - joueur.largeur
    
class Riviere(LignePlancheDeJeu):
    def __init__(self, largeur=10,direction = 0.5, nbPonts = 3):
        LignePlancheDeJeu.__init__(self, largeur, direction)
        self.varFonction = self.collisions
        self.nbPonts = nbPonts
        
        self.ajouterElements()
        
    def ajouterElements(self):
        for i in range(self.nbPonts):
            largeur = random.randint(2,3)
            if self.direction > 0:
                self = PlacementAleatoire.placementElement(Pont(Position(0,None),largeur), self)
            else:
                self = PlacementAleatoire.placementElement(Tortue(Position(0,None),largeur), self)

        self.verifierErreurs()
            
            
        
    def collisions(self, joueur):
        elemColision = self.verifierCollisionsGap(joueur, 0.5)
        if elemColision:
            #il faudra faire suivre la grenouille sur le pont
            elemColision.varFonction(joueur, self.direction)
        else:
            joueur.creve()
            
    
class Rue(LignePlancheDeJeu):
    def __init__(self, largeur=10, direction = 0.5, gapMinimal=2, nbVoitures=3):
        LignePlancheDeJeu.__init__(self, largeur, direction)
        self.nbVoitures = nbVoitures
        
        self.varFonction = self.collisionsRue
        
        self.ajouterElements()
        
    def collisionsRue(self, joueur):
        if self.verifierCollisions(joueur):
            joueur.creve()
        
            
    def ajouterElements(self):
        for i in range(self.nbVoitures):
            largeur = random.randint(2,3)
            if largeur == 2:
                self = PlacementAleatoire.placementElement(Voiture(Position(0,None),largeur), self)
                #self.listeElem.append(Voiture(Position(0,None),largeur))
            else:
                self = PlacementAleatoire.placementElement(Camion(Position(0,None),largeur), self)
                
        self.verifierErreurs()
        
class Trottoir(LignePlancheDeJeu):
    def __init__(self, largeur=10):
        LignePlancheDeJeu.__init__(self, largeur)
        
class Marais(Riviere):
    def __init__(self, largeur=10, nbAnses = 2, largeurAnse = 1.5, direction = 0):
        self.nbAnses = nbAnses
        self.largeurAnse = largeurAnse
        Riviere.__init__(self, largeur, direction, 0)
        
        
    def ajouterElements(self):
        print self.largeur
        largeurParAnse = float(self.largeur) / self.nbAnses
        print largeurParAnse
        for i in range(self.nbAnses):
            ptMilieu = largeurParAnse * (i+1) - largeurParAnse /2
            print ptMilieu
            self.ajouterElement(Anse(Position(ptMilieu-self.largeurAnse/2, None), self.largeurAnse))
            
        
        
        
if __name__ == '__main__':
    class JoueurTest:
        def __init__(self):
            self.pos=Position(0,0)
            self.largeur=1
            
    ligne = LignePlancheDeJeu()
    v1 = Vehicule(Position(0,0))
    v2 = Vehicule(Position(0,0))
    joueur = JoueurTest()
    ligne.ajouterElement(v1)
    ligne.ajouterElement(v2)
    print "collision (devrait etre true:)", ligne.verifierCollisions(joueur)
    joueur.pos = Position(8,0)
    print "collision (devrait etre false:)", ligne.verifierCollisions(joueur)